A protocol for the use of cloud-based quantum computers for logical network analysis of biological systems

Summary Boolean networks are commonly used in systems biology to dynamically model gene regulatory interactions. Here, we present a protocol for implementing Boolean network dynamics as quantum circuits. We describe steps for accessing cloud-based quantum processing units offered by IBM and IonQ and downloading and parsing logic for gene regulatory networks. We then detail procedures for performing simulations of quantum circuits on local devices and visualizing measurement results. For complete details on the use and execution of this protocol, please refer to Weidner et al.1


SUMMARY
Boolean networks are commonly used in systems biology to dynamically model gene regulatory interactions. Here, we present a protocol for implementing Boolean network dynamics as quantum circuits. We describe steps for accessing cloud-based quantum processing units offered by IBM and IonQ and downloading and parsing logic for gene regulatory networks. We then detail procedures for performing simulations of quantum circuits on local devices and visualizing measurement results. For complete details on the use and execution of this protocol, please refer to Weidner et al. 1

BEFORE YOU BEGIN
Before describing the creation of quantum circuits for analyses of logical networks, we show the account setup process for obtaining access to cloud-based quantum processors.

Setting up an account for use of the IBM quantum cloud
Timing: 30-45 min In this section, we set up all the needed requirements to run jobs on the IBM quantum devices through the IBM Quantum Cloud platform.
Note: IBM has introduced a pay-as-you-go scheme, which allows access to 27-qubit quantum processors without requiring membership to the IBM Quantum network. Prices are currently at 1.60$ per second of runtime on the device, payable via credit card or IBM Cloud credits.
In the following we explain how to set up an account and the required instance to send tasks to these devices.
1. Go to the registration portal at https://cloud.ibm.com/registration?target=%2Fquantum. 2. Follow the steps the portal requires: a. Provide a valid e-mail and password for the new account and verify the account.
e. In the following page you can retrieve your CRN as shown in Figure 6, highlighted in green. This code, together with the API key retrieved before, will be used in step 5a.
Note: This code serves as a globally unique identifiers for cloud resources. For further documentation on the role of CRNs for IBM Cloud computing, please check https://cloud.ibm. com/docs/account?topic=account-crn CRITICAL: The red-highlighted box in Figure 6 shows where to set a time limit for the computation run on the quantum device. Remember to set a time limit according to your needs to avoid unnecessary costs due to coding or algorithmic errors! 5. Now we connect to the IBM instance we just created from our notebook (STARProtocol.ipynb), accessing the computational resources we need. To do so: a. Save on disk the account credentials using the following code (you need to insert in quotation marks the API key from step 3c and the CRN from step 4e): QiskitRuntimeService.save_account(channel="ibm_cloud", token=apikey, instance=crn, name=name) b. Connect to the service by calling the account as follows: Everything is now in place to run the necessary algorithms on a simulator or a real quantum device.

Setting up an account for use of the IonQ QPU with Amazon Braket
Timing: 45-60 min In this section we set up all the needed requirements to run jobs on the IonQ quantum device through the Amazon Braket platform.  For further details about this quantum processor, the technology enabling its features and more, an overview is available at https://ionq.com/quantum-systems/harmony. Currently, the cost of using this processor consists of a flat 0.30$ USD per task plus 0.01$ USD for each shot (i.e., for each run of a quantum circuit followed by a measurement).
Here, we will focus on access via Amazon Braket and its associated python SDK. 6. Sign up to the AWS platform: a. Go to https://portal.aws.amazon.com/billing/signup#/start/email; b. Insert a valid e-mail and account name, the e-mail will be verified through verification code. Afterward, set a password. c. Insert all required data about account holder and bank account, then verify your bank account and identity by following the provided instructions. d. Select basic support in the following page to complete the account setup. e. Log into your account using the provided email and password. 7. Once logged in, go to the page https://us-east-1.console.aws.amazon.com/s3/get-started? region=us-east-1 and click on ''Create bucket'' as shown in Figure 7. 8. In the next page insert a name for the bucket on creation and follow the steps to complete the settings of the bucket. The name of the bucket should begin with ''amazon-braket-'' followed by the desired name.
Note: Default settings work for the purpose of this protocol. 9. In the following page, click on the name of the bucket to enter its setting page, as shown in Figure 8. Note: This page lists all the existing buckets, including the one just created.
CRITICAL: The name of the bucket, under ''Name'', will be important as a parameter to insert in the working notebook.
10. In the following page click on ''Create folder'' as shown in Figure 9 and, in the interface opening this way, insert a valid name for the created folder.
Note: Here, all the results of the quantum computation on the IonQ device will be stored.
11. After creating the folder, the page is redirected to the page shown in Figure 8. Save the name of this folder as you will need later to insert it in the notebook.
Note: Now we retrieve the access key and secret access key: these will be used for a one-time initial setup of the AWS services on a local device. To do so: 12. Go to https://console.aws.amazon.com/iam/ 13. Click on ''Users'', as shown in Figure 10. 14. In the new window, click on ''Add users'', if a user is not already present, as shown in Figure 11. 15. In the next page, insert a valid username in the dedicated box and press ''next'', then keep the default options and press again ''next''. Finally, on the next window press ''Create user''. 16. The webpage now redirects on the one shown in Figure 11, where now appears the newly created user. Access the settings of the user by clicking on the username. 17. In the newly opened page, as shown in Figure 12, click firstly on ''Security credentials'' and then on ''Create access key''. 18. In the next window, select ''Other'' from the dotted list and press ''Next''. Then, in the following page, optionally insert a tag name for the access key and press ''Create access key''. 19. Now it is possible to retrieve the Access key and the Secret access key.
CRITICAL: the latter can only be retrieved from this window and will not be shown again! By pressing on ''Show'' it is possible to see and copy the Secret access key. By clicking on ''Download .csv file'' it is possible to download these two keys in a .csv file readable by any text editor. This is shown in Figure 13.
Note: The next step requires the AWS CLI. It can be downloaded for all major operating systems from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html#gettingstarted-install-instructions. Once on the website, follow the instructions to download and install it. To check whether the installation was successful, open your terminal or PowerShell and run the command 20. Finally, these keys must be stored locally on the device. To save the keys, execute the following command and follow the prompted instructions. When asked for the region name, provide the one listed in the bucket, as seen in Figure 8.  Alternative: Use the Jupyter notebook ''STARProtocol.ipynb'' along with the two networks provided as txt files in the 'networks' folder of the GitHub repository associated with this protocol (https://github.com/sysbio-bioinf/QuantumSTARProtocol). The files for any other Boolean network to be analyzed should be placed in the same 'networks' folder.

KEY RESOURCES
Installing BoolNet to convert network rules into txt format

Timing: 5 min
We here explain how to use the BoolNet package for R for parsing the networks obtained in the previous section.
5. Download and install the latest version of R following the instructions at https://cran.r-project. org/ for your operating systems. 6. Download and install RStudio following the instructions at https://rstudio.com/ide for your operating system. 7. Open RStudio and run the command in the console to install the latest version of BoolNet 3 from CRAN.
8. Run the function convertRules() in the file convertRules.R provided on the GitHub repository. This takes the arguments 'SBML' and 'savePath' for the paths where the provided SBML file is located as well as the desired location to save the .txt file.
Note: Boolean networks may contain time delays, meaning that the update of a gene's state relies on that gene's state more than one time step in the past. When networks are obtained from the Cell Collective and represented using BoolNet notation in txt format, such delays are indicated by square brackets. E.g. the appearance of a term such as ''Fgf8[-2]'' in a Boolean rule means that the rule's output is calculated based on the value of Fgf8 two time steps in the past. The proposed methods can not be applied to networks containing such time delays in their rules.
Installing software packages to run algorithms on quantum devices

Timing: 5 min
In this section, we explain an alternative way to install the required Python packages, including the Qiskit environment, which does not rely on the provided Jupyter notebook directly.
In the specified GitHub repository, we provide a requirements.txt file which can be used to install all libraries that are required for the following analyses. This includes, among others, the Qiskit and Amazon Braket SDKs for the creation and simulation of quantum circuits, and the qiskit-ibm-runtime library for sending tasks to real IBM quantum processors using the Runtime environment.
To do so: 9. Create a new virtual environment in the programming language Python named 'myenv' using the command if Conda is installed.
10. Activate this environment using 11. Install the libraries locally using the command with the downloaded file.

Mapping Boolean rules to quantum circuits
Timing: seconds In this section we describe how the Boolean logic can be mapped into quantum circuits. This process is an essential block for the algorithms described further below.
The function parse_BoolNetRules(rulestxt = ''./networks/Giacomantonio2010.txt'', saveDir = None) provided in the functionsForProtocol.py file takes the argument 'rulestxt', which specifies the path to the text file containing the Boolean network rules (e.g., for the network of Giacomantonio), and returns a Python file containing the instructions to build the associated quantum circuit. This is done by.
12. Import the file ''functionsForProtocol.py'' in the Jupyter notebook. 13. Run the parse_BoolNetRules() function. This generates a Python file with the name of the network, with the ending ''_rulefile.py''.
Note: The generated ''_rulefile.py'' file includes all Boolean rules used to synthesize quantum circuits for performing state transitions. These are defined using '@classical_function' from the qiskit.circuit library. The package 'tweedledum v1.1.1' was used for the parsing of Boolean logic into quantum circuits.

Simulating the dynamics of a quantum Boolean network locally
Timing: seconds In this section we simulate the dynamics of Boolean networks on quantum devices using the local processor. This procedure is commonly used for testing the created quantum circuit before sending it to a real quantum device.
Note: The main function used for generating circuits performing state transitions is quantum-StateTransition(). This function generates circuits of ðT + 1Þn qubits to simulate T state transitions of an n component network, with each time step being mapped to a separate set of qubits. Qubits are initially in the '0' state by default. The first set of n qubits of these circuits is initialized with a layer of Hadamard gates, creating a uniformly weighted superposition of all N = 2 n states. All dynamical analyses are presented using the n = 5 cortical area 14. Call the function as shown in the following code snippet, which generates a quantum circuit for performing T = 4 consecutive quantum state transitions from an initial uniform superposition state and measures the final register of n qubits, which will stochastically collapse the superposition state on one of the network's two attractors.
Note: This process of initializing, running and measuring the circuit is called a shot, which is then repeated 1000 times, yielding a probability distribution of measurement outcomes.
Note: Given the order of components specified in Giacomantonio2010.txt this returns the unperturbed classical Boolean network's attractor distribution of the states 10010 and 01101 with probabilities of 87.5% and 12.5% respectively. These probabilities are equivalent to the attractor's basin sizes, which denote the relative number of states flowing into a given attractor. In Qiskit, bitstrings denoting gene activity are read from right to left.
Adding noise profiles to a simulator mimicking a real IBM quantum processor Timing: seconds to minutes In this section we simulate a single noisy state transition in the cortical area network using a fake backend imitating the noise profile of a real IBM quantum device.
Note: In addition to exact, noiseless simulations, Qiskit offers the possibility of testing the results and performance of a quantum circuit on simulators that can mimic the error rates of the various real quantum processors by IBM. These are referred to as 'fake' or 'mock' backends. These backends do not access a real device and thus do not require the creation of an IBM Cloud account and their use does not generate any costs. A comparison of the noisy and exact simulations can give a general estimate of the expected fidelity with which a quantum circuit can be executed.
15. To import an existing fake backend, check the list of devices for which this is available. To do this, check the backends available in the qiskit.providers.fake_provider module of Qiskit. 16. Run the following code snippet which adds the noise profile of this backend and simulates a state transition.
Note: We chose as an example to import the FakeToronto backend, mimicking the noise profile of the 27-qubit IBMQ Toronto processor. Note: Since there is a limited set of quantum gates available on the IBMQ Toronto device, the operations performed in the circuit are first transpiled, i.e. decomposed, into these native gates. This transpilation also respects the coupling map of the processor, which specifies which pairs of qubits can execute 2-qubit gates. For example, to perform operations on pairs of qubits that are not connected on the coupling map, swap gates are added. Therefore, the transpiled circuit will be deeper than the circuit executed on the noiseless simulator. The required time for adding the noise profile will increase significantly if more than one noisy state transition is simulated due to the increasing depth of the circuit after transpilation.
Note: The parameter optimization_level can take integer values from 0 to 3, with 0 indicating no optimization while 3 denotes the maximal optimization to result in a decomposition that is as shallow as possible. The chosen optimized transpilation is a partially stochastic process which will yield circuits of varying depths. This can be prevented by adding an optional value for the seed_transpiler argument. This can be an arbitrary integer, e.g. seed_transpiler = 123, however the same value should be kept for all future simulations to ensure reproducibility. The noise profile thus applies coherence times as well as gate errors stored in the FakeToronto() backend model. The provided Jupyter notebook also includes a visualization which compares the resulting distributions as bar plots. Additionally, we calculate fidelity measures to quantify their similarity.
Using parameterized circuits to gradually vary initial gene activities

Timing: seconds
We use rotation gates to modify the bias of the initial qubit states, thus changing the probabilities associated with attractors.
Note: Using the additional arguments 'initActivities' and 'thetatype' for the quantumState Transition() function, we can continuously tune the activity of genes in the initial superposition state.
Here, initActivities is an array of n elements, with the i-th element indicating the bias for the i-th gene in the network file. These angles correspond to the polar angle on the Bloch sphere, i.e., 0 is identical to the default '0' state and a R y ðq = 90 Þ rotation would yield the same result as the previously used Hadamard gates. The argument 'thetatype' specifies whether the rotation is given as an 'angle' or 'radian'.
17. Call the function in the following code snippet, which exemplarily simulates a steady increase in the initial activity of the first component listed in the network, Fgf8, please also refer to Weidner et al. 1 (supplement section 4). 18. Verify that for q = 0 , only the 10010 attractor is found, indicating that the entire subspace of 2 nÀ1 = 16 states where Fgf8 is inactive leads to this attractor. The weight of the 01101 should then gradually increases with the bias of the tuned component towards the '1' state.

Simultaneous knockout and overexpression simulations by use of superposition perturbations
Timing: seconds In this section, we use superposition states as perturbations of the network dynamics. This is done by using the initActivities and initPerturbed arguments of the quantumStateTransition() function.
Note: 'initActivities' specifies if genes should be perturbed with a particular superposition state. We do this using an additional Boolean vector: initPerturbed. If entries in this vector are True, the corresponding initial state created by the R y ðqÞ rotations specified in initActivities will be re-used after every quantum state transition.
Note: For angles that are not 0 or 180 , this is equivalent to simultaneously performing a classical knockout (KO) and overexpression (OE) simulation, both of which may alter the system's attractor landscape.

Execute the first function call in the following code snippet where the third network component
Pax6 is perturbed with a bias towards OE.
Note: This returns attractors from both a KO and OE simulation, however those of the OE perturbation will contribute with larger probabilities than would be the case in an unbiased averaging of attractor basin sizes.
20. Execute the second function call, where a second perturbation with a bias towards KO for the fifth component, Coup_tfi, is added. This returns the union set of all attractors from the four possible double perturbations.

Performing inverted state transitions by amplitude amplification
Timing: seconds We exploit the reversibility of quantum circuits in combination with Grover's algorithm to amplify the probability of states that are predecessors of a specified attractor.
Note: The following code generates a circuit implementing G = 2 iterations of the Grover operator, i.e. two repetitions of oracle and diffuser. The marked state is the attractor ll OPEN ACCESS 01101, whose predecessors and pre-predecessors (nrTransitions = 2) will be amplified. That is, this Grover search effectively performs inverted state transitions. Single-state attractors such as 01101 are their own predecessors, thus all four states in the basin of attraction of this attractor (01101, 11101, 11001, 01001) will have their probabilities of measurement increased. Repeated runs and measurements of this circuit will yield a probability distribution over all possible 2 5 = 32 states of this 5-gene network.By repeated measurement, we found that the circuit has a probability of 93.4% to yield one of these four states in the basin of attraction even though they make up only 12.5% of the system's state space.
To reproduce the same analysis.
21. Run the following code snippet to amplify the predecessor states of the 'markedState' attractor 01101 using G = 2 iterations of the Grover operator. 22. Verify that the solution probability is larger than the 4/32 = 12.5% probability which would be expected from random sampling.
Optional: Change the parameter G to see how the amplification of the four solution states varies. The degree to which predecessor states are amplified depends on the number of iterations G. The optimal value for this parameter depends on the total number of solutions, which can be determined by quantum counting, as described further below.

Basin size estimation using quantum counting
Timing: seconds to minutes In this section, we use a quantum counting algorithm to count the total number of solutions states instead of amplifying their probabilities as in the previous section.
Note: The quantum counting algorithm combines the Grover operator with a quantum Fourier transform to estimate the total number of solutions M of a Grover search. Results are measured on a separate readout register of qubits, whose length 'r_registerLen' determines the accuracy of the obtained value. The measured bitstrings here no longer correspond to gene activity but instead represent the binary encoding of an integer value for M. In the examples shown below, the state 00000 has 14 immediate predecessors, while the attractor 01101 has a basin size of 4, which is reached after at least two inverted transitions, as in the Grover search before.
23. Run the first function call to QuantumCountingAlgo() in following code snippet, which estimates the number of immediate predecessors of the state 00000 (14 states in total in the classical system). 24. Run the second function call to QuantumCountingAlgo(), which estimates all predecessors of the 01101 attractor up to 2 transitions away from the attractor (4 states in total in the classical system).

Submitting tasks to IBM's quantum processors
Timing: seconds to hours, depends on queue and whether the device is currently online or undergoing maintenance In this section we submit the circuits we created to the IBM quantum devices to be run.
Note: IBM Qiskit Runtime is a new framework used to access IBM's quantum processing units, offering in-built optimization procedures aimed at simplifying commonly performed analyses. A prominent feature of the Runtime framework is the possibility to apply some techniques of error suppression and mitigation in an automated way.
Making use of the code in the snippet below, execute the following steps.
25. Define a runtime service based on the account previously saved (in the snippet). 26. Generate a circuit for a single state transition from a uniform superposition state (in the snippet). 27. Transpile the generated circuit to match the set of gate operations available on the 'ibm_algiers' quantum device (in the snippet). 28. Monitor the status of the running job on the quantum device, after it gets assigned a job_id, under 'Jobs' in the associated instance in the IBM quantum cloud (on the IBM cloud webpage). See troubleshooting problem 1, problem 2, problem 3. 29. Read the results from the dictionary saved in the ''result'' variable.
Note: The 'binary_probabilities()' line indicates that states are to be listed as bitstrings as before instead of decimal integers (e.g. without this line the result would be presented in such a way that 00011 -> 3), to more easily evaluate which network components are active or inactive. Optional: by adding the two lines of code ''options.resilience_level = num'' and ''options.op-timization_level = num'' it is possible to access and modify the error mitigation and error suppression techniques currently available within the Runtime framework. Both parameters can range from 0 (no mitigation/suppression) to 3 (maximum mitigation/suppression).

Timing: Minutes to hours
In this section we make use of error mitigation techniques to improve the quality of the results provided by the quantum device.
Note: On top of the error mitigation and suppression techniques offered by the runtime framework, other methods can be used to better refine the results one can obtain from a quantum computer. We provide here one example: Multiple transpilation. The transpilation of an algorithm on to a quantum device is not a unique process, but can be performed in different, yet theoretically equivalent ways. The performance of these different transpiled algorithms on a quantum device can be very different though, providing a motivation to try to find the optimal one to perform the required analysis. As Qiskit transpilation methods, though relying on several optimization methods, still involve stochasticity to a certain degree, it is possible to perform the transpilation of a given algorithm multiple times and select among those the one thought to be the best one upon a chosen criterion. In our case, we choose the transpilation with the least number of CNOT gates involved.
To perform Multiple transpilation: 30. Define the quantum circuit to be executed (CorticalNetTransition in the snippet below). 31. Transpile multiple times the same circuit: in general these transpilations will be different from each other. 32. Count the number of CNOT gates present in each of the different transpilations. 33. Select as the preferred choice the transpilation with the least number of CNOT gates. 34. Run the selected quantum circuit with the same method used for the circuits above. See troubleshooting problem 1, problem 2, problem 3.

Running quantum circuits on an IonQ's QPU using AWS braket
Timing: hours, depending on time at which task was sent and queue of the device In this section, we send a task for the simulation of a quantum state transition to the Amazon Braket cloud using the account that was set up in the ''Before you begin'' section.
To run tasks on the IonQ quantum processor, provide the name of your bucket and a folder inside that bucket after having saved your keys using ''aws configure''.
Note: The estimated cost for all tasks run using your AWS account can be seen by clicking your account name in the top right corner -> ''Account'' -> ''Bills''. Additional payment methods can be added under ''Account'' -> ''Payment preferences''. When a new credit card is added, AWS will send a 1,00$ authorization charge to verify the legitimacy of the card.
35. Replace the variables ''my_bucket'' and ''my_prefix'' with your specific information as described in the ''before you begin'' section. 36. Run the code snippet to obtain a cost estimate.
Note: If the QPU is offline, we can use the SV1 simulator for testing purposes.
37. Run the following code, which generates a circuit performing a single state transition, analogous to the one shown in the previous analysis using Qiskit Runtime, sends out the task and prints the results. See troubleshooting problem 1, problem 4, problem 5, problem 6. Note: To run circuits generated in Qiskit on the IonQ processor, we rewrite the circuits to be executable on the natively available set of basis gates of the device. The returned results are also parsed back into dictionaries in the qiskit format. This is necessary as gate names differ between the two frameworks. For the IonQ device, all qubits are measured. The probabilities concerning only the activities of the desired qubits corresponding to the output of the state transition are then summed up. These transformations are performed by the custom functions QiskitQASM2IonQcompiler() and ionqDict2qiskitNotation().
Note: The poll_timeout_seconds argument when running a circuit using Braket gives the value in seconds for which a task will be polled for results. It is set to a default value corresponding to The average expected queue time can be checked at https://status.ionq.co/ along with the current status of the QPU. This site also lists any recent incidents which may be informative if a job is not being executed.

EXPECTED OUTCOMES
If the simulations performed by the code snippets in this protocol have been executed correctly, the results from both real quantum processors as well as local simulators should be returned in the form of dictionaries. These dictionaries contain the results of repeated 'shots' of quantum circuits, meaning the repeated processing of initializing, running and measuring the circuit, yielding a single specific bitstring each time.

LIMITATIONS
The execution of this protocol is dependent on the uptime of the quantum processing units used to execute the quantum circuits. These devices undergo regular maintenance. During this time, or if the device is offline for any other reason, previously sent tasks will remain in the queue and need not to be sent out again.
Furthermore, the time point of the latest calibration of the device may have an effect on the results, which can not be controlled by the user.
For the IonQ device, uptime follows a schedule of being online from 13:00 to 2:00 UTC on weekdays.
IBM devices may be offline or have a paused queue without previous notice. The state of these devices can be checked on the IBM Quantum cloud dashboard on https://cloud.ibm.com/quantum/ resources/systems under ''Your resources''.
The quantum cloud services of both IBM and Amazon are continuously evolving and being updated.In case of future changes, the official documentation may provide further information: https:// quantum-computing.ibm.com/docs/ https://docs.aws.amazon.com/braket/index.html Additionally, the user may check the GitHub repository listed in the data and code availability statement for future updates.

TROUBLESHOOTING Problem 1
Tasks for the real quantum processors are stuck in a queue and are not being executed (steps 28,34,37).

Potential solution
Check the status of the processors for notifications informing about potential issues with the hardware preventing execution.

Problem 2
Tasks on the IBM quantum cloud are running but are being canceled before the task finishes (steps 28, 34).

Potential solution
Check if the current task has surpassed the cost limit of the instance and if so, increase the limit. Note that the cost limits refer to the total runtime of all tasks that have so far been run on the instance and not any remaining runtime to be added.

Potential solution
Check that the QiskitRuntimeService() function call uses the ''ibm_cloud'' channel and that both the API token and CRN are correct. If the error persists, create a new API token under https://cloud.ibm. com/iam/apikeys.

Problem 4
Tasks for the IonQ device do not execute, giving an error of the type ''Could not connect to the endpoint URL'' (step 37).

Potential solution
Select a different region, e.g., ''us-east-1'' for the IonQ device, as QPUs are region specific. Rerun the command ''aws configure'' and update this information. Create a new bucket in the new region.

Problem 5
Tasks for the IonQ device do not execute, giving an error of the type ''InvalidSignatureException when calling GetDevice operation: Signature expired.'' (step 37).

Problem 6
Tasks for the IonQ device do not execute, giving an error of the type ''An error occurred (AccessDeniedException) when calling the GetDevice operation: User . is not authorized to perform: braket:GetDevice on resource: . /qpu/ionq/Harmony'' (step 37).

Potential solution
Open the IAM dashboard, go to ''Access Management''-> ''Users'' and select your username. Go to ''Add permissions'' and add the permission policy ''AmazonBraketFullAccess'' to this user.

RESOURCE AVAILABILITY
Lead contact Further information and requests for resources and reagents should be directed to and will be fulfilled by the lead contact, Hans A. Kestler (hans.kestler@uni-ulm.de).

Materials availability
This study did not generate new unique reagents.

Data and code availability
The code generated during this study is available at https://github.com/sysbio-bioinf/QuantumSTAR Protocol or alternatively via Zenodo under https://doi.org/10.5281/zenodo.8023318. This includes the ll OPEN ACCESS rules of the Boolean networks used in this protocol as well as the code required for running the presented analyses as a Jupyter notebook. Please note that libraries and functions related to Qiskit are subject to frequent updates and changes and may become deprecated in the future.